home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / kernel / proc / sun3.md / procMach.c < prev    next >
C/C++ Source or Header  |  1992-12-18  |  8KB  |  261 lines
  1. /* procMach.c --
  2.  *
  3.  *    Routine to interpret file header.
  4.  *
  5.  * Copyright (C) 1989 Digital Equipment Corporation.
  6.  * Permission to use, copy, modify, and distribute this software and
  7.  * its documentation for any purpose and without fee is hereby granted,
  8.  * provided that the above copyright notice appears in all copies.  
  9.  * Digital Equipment Corporation makes no representations about the
  10.  * suitability of this software for any purpose.  It is provided "as is"
  11.  * without express or implied warranty.
  12.  */
  13.  
  14. #ifndef lint
  15. static char rcsid[] = "$Header: /cdrom/src/kernel/Cvsroot/kernel/proc/sun3.md/procMach.c,v 9.11 92/01/08 01:11:53 shirriff Exp $ SPRITE (DECWRL)";
  16. #endif /* not lint */
  17.  
  18. #include <sprite.h>
  19. #include <stdio.h>
  20. #include <procMach.h>
  21. #include <proc.h>
  22. #include <procInt.h>
  23. #include <status.h>
  24.  
  25. extern int debugProcStubs;
  26.  
  27.  
  28. /*
  29.  *----------------------------------------------------------------------
  30.  *
  31.  * ProcGetObjInfo --
  32.  *
  33.  *    Translate the object file information into the machine independent
  34.  *    form.
  35.  *
  36.  * Results:
  37.  *    SUCCESS if could translate.
  38.  *    PROC_BAD_AOUT_FORMAT if could not.
  39.  *
  40.  * Side effects:
  41.  *    *objInfoPtr is filled in.
  42.  *
  43.  *----------------------------------------------------------------------
  44.  */
  45. ReturnStatus
  46. ProcGetObjInfo(filePtr, execPtr, objInfoPtr)
  47.     Fs_Stream        *filePtr;
  48.     ProcExecHeader    *execPtr;
  49.     ProcObjInfo        *objInfoPtr;
  50. {
  51.  
  52.     int data[14];
  53.     int sizeRead;
  54.     ReturnStatus status;
  55. #ifndef sun3
  56.     int excess;
  57. #endif
  58. #define TYPE_SPRITE 0
  59. #define TYPE_UNIX 0x1000
  60.     int type;
  61.  
  62. #ifdef sun2
  63.     if (execPtr->machineType != PROC_MC68010) {
  64.     return(PROC_BAD_AOUT_FORMAT);
  65.     }
  66. #endif
  67. #ifdef sun3
  68.     if (execPtr->machineType != PROC_MC68010 &&
  69.         execPtr->machineType != PROC_MC68020) {
  70.     return(PROC_BAD_AOUT_FORMAT);
  71.     }
  72. #endif
  73. #ifdef sun4
  74.     /*
  75.      * Sun's compiler includes a tool version number or something in the
  76.      * top 16 bits of the machineType field, so we can only look at the
  77.      * low 16 bits.
  78.      */
  79.     if ((execPtr->machineType & 0xff) != PROC_SPARC) {
  80.     return(PROC_BAD_AOUT_FORMAT);
  81.     }
  82. #endif
  83.     /*
  84.      * The following few lines are total hack.  The idea is to look at
  85.      * the startup code to see if it was a Sprite-compiled file, or
  86.      * a Unix-compiled file.
  87.      */
  88.     sizeRead = 14*sizeof(int);
  89.     status = Fs_Read(filePtr, (char *)data,
  90.     execPtr->entry-PROC_CODE_LOAD_ADDR(*execPtr), &sizeRead);
  91.     if (status != SUCCESS) {
  92.     printf("READ failed\n");
  93.     return(PROC_BAD_AOUT_FORMAT);
  94.     }
  95. #ifdef sun3
  96.     if (data[0]==0x241747ef && data[1]==0x42002 &&
  97.         (data[2]==0x52807204 || data[2]==0x5280223c) &&
  98.         ((data[3]&0xffff0000)==0x4eb90000 || data[3]==4)) {
  99. #else
  100.     /* Normal sun4 startup code */
  101.     if ((data[0]==0xac10000e && data[1]==0xac05a060 &&
  102.         data[2]==0xd0058000 && data[3]==0x9205a004) ||
  103.     /* Profiled sun4 startup code */
  104.     (data[10]==0xac10000e && data[11]==0xac05a060 &&
  105.         data[12]==0xd0058000 && data[13]==0x9205a004)) {
  106.  
  107. #endif
  108.     type = TYPE_SPRITE;
  109.     } else {
  110.     type = TYPE_UNIX;
  111. #ifdef sun3
  112.     /*
  113.      * Special check for emacs, which has weird startup code.
  114.      */
  115.     if (data[0]==0x4e560000 && data[1]==0x61064e5e &&
  116.         data[2]==0x4e750000) {
  117.         type = TYPE_SPRITE;
  118.     }
  119. #endif
  120.     }
  121.  
  122.     switch (execPtr->magic | type) {
  123.  
  124.     case PROC_ZMAGIC:        /* demand-paged */
  125.     objInfoPtr->codeLoadAddr = (Address)PROC_CODE_LOAD_ADDR(*execPtr);
  126.     objInfoPtr->codeFileOffset = PROC_CODE_FILE_OFFSET(*execPtr);
  127.     objInfoPtr->codeSize = execPtr->code;
  128.     objInfoPtr->heapLoadAddr = (Address)PROC_DATA_LOAD_ADDR(*execPtr);
  129.     objInfoPtr->heapFileOffset = PROC_DATA_FILE_OFFSET(*execPtr);
  130.     objInfoPtr->heapSize = execPtr->data;
  131.     objInfoPtr->bssLoadAddr = (Address)PROC_BSS_LOAD_ADDR(*execPtr);
  132.     objInfoPtr->bssSize = execPtr->bss;
  133.     objInfoPtr->entry = (Address)execPtr->entry;
  134.     objInfoPtr->unixCompat = 0;
  135.  
  136.     break;
  137.  
  138.     case PROC_OMAGIC:
  139.     objInfoPtr->codeLoadAddr = (Address)PROC_CODE_LOAD_ADDR(*execPtr);
  140.     objInfoPtr->codeFileOffset = 0;
  141.     objInfoPtr->codeSize = 0;
  142.     objInfoPtr->heapLoadAddr = (Address)PROC_CODE_LOAD_ADDR(*execPtr);
  143.     objInfoPtr->heapFileOffset = PROC_CODE_FILE_OFFSET(*execPtr);
  144.     objInfoPtr->heapSize = execPtr->data + execPtr->code;
  145.     objInfoPtr->bssLoadAddr = (Address)PROC_BSS_LOAD_ADDR(*execPtr);
  146.     objInfoPtr->bssSize = execPtr->bss;
  147.     objInfoPtr->entry = (Address)execPtr->entry;
  148.     objInfoPtr->unixCompat = 0;
  149.     break;
  150.  
  151.     case UNIX_ZMAGIC:
  152.     case PROC_ZMAGIC|TYPE_UNIX:
  153.     if (debugProcStubs) {
  154.         printf("Executing UNIX file in compatibility mode.\n");
  155.     }
  156.     objInfoPtr->codeLoadAddr = (Address) PROC_BASEADDR(*execPtr);
  157.  
  158.     objInfoPtr->codeFileOffset = PROC_CODE_FILE_OFFSET(*execPtr);
  159.     objInfoPtr->codeSize = execPtr->code;
  160. #ifdef sun3
  161.     objInfoPtr->heapLoadAddr = (Address) PROC_SUN_DATA_LOAD_ADDR(*execPtr);
  162.     objInfoPtr->heapFileOffset = PROC_DATA_FILE_OFFSET(*execPtr);
  163.     objInfoPtr->heapSize = execPtr->data;
  164.     objInfoPtr->bssLoadAddr = objInfoPtr->heapLoadAddr + execPtr->data;
  165. #else
  166.     /*
  167.      * We have to shuffle things around so the heap is on a pmeg
  168.      * boundary.  This involves loading some of the code as heap.
  169.      */
  170.     objInfoPtr->heapLoadAddr = (Address) (((int) objInfoPtr->codeLoadAddr +
  171.         execPtr->code) & ~(NEW_SEG_SIZE - 1));
  172.  
  173.     if (objInfoPtr->heapLoadAddr < objInfoPtr->codeLoadAddr) {
  174.         objInfoPtr->heapLoadAddr = objInfoPtr->codeLoadAddr;
  175.     }
  176.     objInfoPtr->heapFileOffset = PROC_DATA_FILE_OFFSET(*execPtr);
  177.     objInfoPtr->heapSize = execPtr->data;
  178.     excess = (objInfoPtr->codeLoadAddr+execPtr->code) -
  179.         objInfoPtr->heapLoadAddr;
  180.     objInfoPtr->heapFileOffset -= excess;
  181.     objInfoPtr->heapSize += excess;
  182.     objInfoPtr->codeSize -= excess;
  183.     objInfoPtr->bssLoadAddr = objInfoPtr->codeLoadAddr + execPtr->code +
  184.         execPtr->data;
  185.     if (debugProcStubs) {
  186.         printf("excess = %x\n", excess);
  187.     }
  188. #endif
  189.  
  190.     objInfoPtr->bssSize = execPtr->bss;
  191.     objInfoPtr->entry = (Address)execPtr->entry;
  192.     objInfoPtr->unixCompat = 1;
  193.     if (debugProcStubs) {
  194.         printf("ZMAGIC: code at %x (%x), heap at %x (%x), bss at %x (%x)\n",
  195.             objInfoPtr->codeLoadAddr, objInfoPtr->codeSize,
  196.             objInfoPtr->heapLoadAddr, objInfoPtr->heapSize,
  197.             objInfoPtr->bssLoadAddr, objInfoPtr->bssSize);
  198.     }
  199.     break;
  200.  
  201.     case PROC_NMAGIC|TYPE_UNIX:
  202.     objInfoPtr->codeLoadAddr = (Address) PROC_BASEADDR(*execPtr);
  203.  
  204.     objInfoPtr->codeFileOffset = PROC_CODE_FILE_OFFSET(*execPtr);
  205.     objInfoPtr->codeSize = execPtr->code;
  206. #if 1
  207. #ifdef sun3
  208.     objInfoPtr->heapLoadAddr = (Address) PROC_DATA_LOAD_ADDR(*execPtr);
  209. #else
  210.     objInfoPtr->heapLoadAddr = (Address) PROC_SUN_DATA_LOAD_ADDR(*execPtr);
  211. #endif
  212.     objInfoPtr->heapFileOffset = PROC_CODE_FILE_OFFSET(*execPtr)+
  213.         execPtr->code;
  214.     objInfoPtr->heapSize = execPtr->data;
  215. #else
  216. #ifdef sun3
  217.     objInfoPtr->heapLoadAddr = (Address) PROC_DATA_LOAD_ADDR(*execPtr);
  218.     objInfoPtr->heapFileOffset = PROC_CODE_FILE_OFFSET(*execPtr)+
  219.         execPtr->code;
  220.     objInfoPtr->heapSize = execPtr->data;
  221. #else
  222.  
  223.     /*
  224.      * We have to shuffle things around so the heap is on a pmeg
  225.      * boundary.  This involves loading some of the code as heap.
  226.      */
  227.     objInfoPtr->heapLoadAddr = (Address) (((int) objInfoPtr->codeLoadAddr +
  228.         execPtr->code) & ~(NEW_SEG_SIZE - 1));
  229.     if (objInfoPtr->heapLoadAddr < objInfoPtr->codeLoadAddr) {
  230.         objInfoPtr->heapLoadAddr = objInfoPtr->codeLoadAddr;
  231.     }
  232.     objInfoPtr->heapFileOffset = PROC_DATA_FILE_OFFSET(*execPtr);
  233.     objInfoPtr->heapSize = execPtr->data;
  234.     excess = (objInfoPtr->codeLoadAddr+execPtr->code) -
  235.         objInfoPtr->heapLoadAddr;
  236.     objInfoPtr->heapFileOffset -= excess;
  237.     objInfoPtr->heapSize += excess;
  238.     objInfoPtr->codeSize -= excess;
  239. #endif
  240. #endif
  241.  
  242.     objInfoPtr->bssLoadAddr = objInfoPtr->heapLoadAddr + execPtr->data;
  243.     objInfoPtr->bssSize = execPtr->bss;
  244.     objInfoPtr->entry = (Address)execPtr->entry;
  245.     objInfoPtr->unixCompat = 1;
  246.     break;
  247.  
  248.     default:
  249.     return(PROC_BAD_AOUT_FORMAT);
  250.     }
  251.     if (debugProcStubs && type==TYPE_UNIX) {
  252.     printf("Code: %x bytes, file %x, mem %x, heap: %x bytes, file %x\n",
  253.         objInfoPtr->codeSize, objInfoPtr->codeFileOffset,
  254.         objInfoPtr->codeLoadAddr, objInfoPtr->heapSize,
  255.         objInfoPtr->heapFileOffset, objInfoPtr->heapLoadAddr);
  256.     printf("bss: %x bytes, mem %x\n", objInfoPtr->bssSize,
  257.         objInfoPtr->bssLoadAddr);
  258.     }
  259.     return(SUCCESS);
  260. }
  261.